package com.smartbus.bus.service.impl;

import java.util.List;
import java.util.ArrayList;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.smartbus.bus.mapper.BusRoutesMapper;
import com.smartbus.bus.domain.BusRoutes;
import com.smartbus.bus.domain.dto.DispatchRouteDTO;
import com.smartbus.bus.service.IBusRoutesService;

/**
 * 公交线路基础信息，存储各条公交线路的基本配置和运营参数Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-09-24
 */
@Service
public class BusRoutesServiceImpl implements IBusRoutesService 
{
    @Autowired
    private BusRoutesMapper busRoutesMapper;

    /**
     * 查询公交线路基础信息，存储各条公交线路的基本配置和运营参数
     * 
     * @param id 公交线路基础信息，存储各条公交线路的基本配置和运营参数主键
     * @return 公交线路基础信息，存储各条公交线路的基本配置和运营参数
     */
    @Override
    public BusRoutes selectBusRoutesById(Long id)
    {
        return busRoutesMapper.selectBusRoutesById(id);
    }

    /**
     * 查询公交线路基础信息，存储各条公交线路的基本配置和运营参数列表
     * 
     * @param busRoutes 公交线路基础信息，存储各条公交线路的基本配置和运营参数
     * @return 公交线路基础信息，存储各条公交线路的基本配置和运营参数
     */
    @Override
    public List<BusRoutes> selectBusRoutesList(BusRoutes busRoutes)
    {
        return busRoutesMapper.selectBusRoutesList(busRoutes);
    }

    /**
     * 新增公交线路基础信息，存储各条公交线路的基本配置和运营参数
     * 
     * @param busRoutes 公交线路基础信息，存储各条公交线路的基本配置和运营参数
     * @return 结果
     */
    @Override
    public int insertBusRoutes(BusRoutes busRoutes)
    {
        return busRoutesMapper.insertBusRoutes(busRoutes);
    }

    /**
     * 修改公交线路基础信息，存储各条公交线路的基本配置和运营参数
     * 
     * @param busRoutes 公交线路基础信息，存储各条公交线路的基本配置和运营参数
     * @return 结果
     */
    @Override
    public int updateBusRoutes(BusRoutes busRoutes)
    {
        return busRoutesMapper.updateBusRoutes(busRoutes);
    }

    /**
     * 批量删除公交线路基础信息，存储各条公交线路的基本配置和运营参数
     * 
     * @param ids 需要删除的公交线路基础信息，存储各条公交线路的基本配置和运营参数主键
     * @return 结果
     */
    @Override
    public int deleteBusRoutesByIds(Long[] ids)
    {
        return busRoutesMapper.deleteBusRoutesByIds(ids);
    }

    /**
     * 删除公交线路基础信息，存储各条公交线路的基本配置和运营参数信息
     *
     * @param id 公交线路基础信息，存储各条公交线路的基本配置和运营参数主键
     * @return 结果
     */
    @Override
    public int deleteBusRoutesById(Long id)
    {
        return busRoutesMapper.deleteBusRoutesById(id);
    }

    /**
     * 获取调度系统线路数据
     *
     * @return 调度线路数据集合
     */
    @Override
    public List<DispatchRouteDTO> getDispatchRoutes()
    {
        List<BusRoutes> busRoutesList = busRoutesMapper.selectBusRoutesList(new BusRoutes());
        List<DispatchRouteDTO> dispatchRoutes = new ArrayList<>();

        String[] routeColors = {"#1890ff", "#52c41a", "#faad14", "#f5222d", "#722ed1", "#13c2c2"};
        String[] routePaths = {
            "M 150 200 L 280 200 L 380 200 L 480 200 L 580 200 L 680 200 L 780 200",
            "M 150 300 L 280 300 L 380 300 L 480 300 L 580 300 L 680 300 L 780 300",
            "M 150 400 L 280 400 L 380 400 L 480 400 L 580 400 L 680 400 L 780 400",
            "M 150 250 L 280 250 L 380 250 L 480 250 L 580 250 L 680 250 L 780 250",
            "M 150 350 L 280 350 L 380 350 L 480 350 L 580 350 L 680 350 L 780 350",
            "M 150 450 L 280 450 L 380 450 L 480 450 L 580 450 L 680 450 L 780 450"
        };

        int[] yPositions = {200, 300, 400, 250, 350, 450};

        for (int i = 0; i < busRoutesList.size() && i < 6; i++) {
            BusRoutes route = busRoutesList.get(i);
            DispatchRouteDTO dto = new DispatchRouteDTO(route.getId(), route.getRouteName(), route.getRouteNumber());

            dto.setColor(routeColors[i % routeColors.length]);
            dto.setPathData(routePaths[i % routePaths.length]);
            dto.setTotalDistance(route.getRouteDistance());
            dto.setEstimatedDuration(route.getEstimatedDuration());
            dto.setOperatingStatus(route.getIsActive() == 1 ? "active" : "inactive");

            dto.setActiveVehicles((int) (Math.random() * 5) + 1);

            // 设置起点和终点坐标
            Map<String, Integer> startPoint = new HashMap<>();
            startPoint.put("x", 150);
            startPoint.put("y", yPositions[i % yPositions.length]);
            dto.setStartPoint(startPoint);

            Map<String, Integer> endPoint = new HashMap<>();
            endPoint.put("x", 780);
            endPoint.put("y", yPositions[i % yPositions.length]);
            dto.setEndPoint(endPoint);

            List<Long> mockStations = Arrays.asList(
                route.getStartStationId(),
                route.getStartStationId() + 1,
                route.getStartStationId() + 2,
                route.getEndStationId()
            );
            dto.setStations(mockStations);

            dispatchRoutes.add(dto);
        }

        return dispatchRoutes;
    }

    /**
     * 获取线路实时运营状态
     *
     * @return 线路状态数据集合
     */
    @Override
    public List<DispatchRouteDTO> getRouteStatus()
    {
        List<DispatchRouteDTO> statusList = getDispatchRoutes();

        for (DispatchRouteDTO route : statusList) {
            route.setActiveVehicles((int) (Math.random() * 8) + 2);

            if (Math.random() > 0.8) {
                route.setOperatingStatus("delayed");
            } else if (Math.random() > 0.9) {
                route.setOperatingStatus("maintenance");
            } else {
                route.setOperatingStatus("active");
            }
        }

        return statusList;
    }
}
